home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / tiff / tif_fax3.c < prev    next >
C/C++ Source or Header  |  1995-06-21  |  31KB  |  1,169 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_fax3.c,v 1.93 1994/09/29 23:46:58 sam Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1990, 1991, 1992, 1993, 1994 Sam Leffler
  5.  * Copyright (c) 1991, 1992, 1993, 1994 Silicon Graphics, Inc.
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26.  
  27. /*
  28.  * TIFF Library.
  29.  *
  30.  * CCITT Group 3 and Group 4 Compression Support.
  31.  */
  32. #include "tiffiop.h"
  33. #include "tif_fax3.h"
  34. #define    G3CODES
  35. #include "t4.h"
  36. #define    G3STATES
  37. #include "g3states.h"
  38. #include <assert.h>
  39. #include <stdio.h>
  40.  
  41. typedef struct {
  42.     Fax3BaseState b;
  43. } Fax3DecodeState;
  44.  
  45. typedef struct {
  46.     Fax3BaseState b;
  47.     short    k;            /* #rows left that can be 2d encoded */
  48.     short    maxk;            /* max #rows that can be 2d encoded */
  49. } Fax3EncodeState;
  50.  
  51. static    int Fax3Decode1DRow(TIFF*, u_char*, uint32);
  52. static    int Fax3Encode1DRow(TIFF*, u_char*, uint32);
  53. static    int32 find0span(u_char*, int32, int32);
  54. static    int32 find1span(u_char*, int32, int32);
  55.  
  56. void
  57. TIFFModeCCITTFax3(TIFF* tif, int isClassF)
  58. {
  59.     if (isClassF)
  60.         tif->tif_options |= FAX3_CLASSF;
  61.     else
  62.         tif->tif_options &= ~FAX3_CLASSF;
  63. }
  64.  
  65. static u_char bitMask[8] =
  66.     { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
  67. #define    isBitSet(sp)    ((sp)->b.data & bitMask[(sp)->b.bit])
  68.  
  69. #define    is2DEncoding(tif) \
  70.     (tif->tif_dir.td_group3options & GROUP3OPT_2DENCODING)
  71. #define    fetchByte(tif, sp) \
  72.     ((tif)->tif_rawcc--, (sp)->b.bitmap[*(u_char *)(tif)->tif_rawcp++])
  73. #define    isWordAligned(tif) \
  74.     (((long) tif->tif_rawcp & 1) == 0)
  75.  
  76. #define    BITCASE(b)            \
  77.     case b:                \
  78.     code <<= 1;            \
  79.     if (data & (1<<(7-b))) code |= 1;\
  80.     len++;                \
  81.     if (code > 0) { bit = b+1; break; }
  82.  
  83. /*
  84.  * Skip over input until an EOL code is found.  The
  85.  * value of len is passed as 0 except during error
  86.  * recovery when decoding 2D data.  Note also that
  87.  * we don't use the optimized state tables to locate
  88.  * an EOL because we can't assume much of anything
  89.  * about our state (e.g. bit position).
  90.  */
  91. static void
  92. skiptoeol(TIFF* tif, int len)
  93. {
  94.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  95.     int bit = sp->b.bit;
  96.     int data = sp->b.data;
  97.     int code = 0;
  98.  
  99.     /*
  100.      * Our handling of ``bit'' is painful because
  101.      * the rest of the code does not maintain it as
  102.      * exactly the bit offset in the current data
  103.      * byte (bit == 0 means refill the data byte).
  104.      * Thus we have to be careful on entry and
  105.      * exit to insure that we maintain a value that's
  106.      * understandable elsewhere in the decoding logic.
  107.      */
  108.     if (bit == 0)            /* force refill */
  109.         bit = 8;
  110.     for (;;) {
  111.         switch (bit) {
  112.     again:    BITCASE(0);
  113.         BITCASE(1);
  114.         BITCASE(2);
  115.         BITCASE(3);
  116.         BITCASE(4);
  117.         BITCASE(5);
  118.         BITCASE(6);
  119.         BITCASE(7);
  120.         default:
  121.             if (tif->tif_rawcc <= 0)
  122.                 return;
  123.             data = fetchByte(tif, sp);
  124.             goto again;
  125.         }
  126.         if (len >= 12 && code == EOL)
  127.             break;
  128.         code = len = 0;
  129.     }
  130.     sp->b.bit = bit > 7 ? 0 : bit;    /* force refill */
  131.     sp->b.data = data;
  132. }
  133.  
  134. /*
  135.  * Return the next bit in the input stream.  This is
  136.  * used to extract 2D tag values and the color tag
  137.  * at the end of a terminating uncompressed data code.
  138.  */
  139. static int
  140. nextbit(TIFF* tif)
  141. {
  142.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  143.     int bit;
  144.  
  145.     if (sp->b.bit == 0 && tif->tif_rawcc > 0)
  146.         sp->b.data = fetchByte(tif, sp);
  147.     bit = isBitSet(sp);
  148.     if (++(sp->b.bit) > 7)
  149.         sp->b.bit = 0;
  150.     return (bit);
  151. }
  152.  
  153. /*
  154.  * Setup G3-related compression/decompression
  155.  * state before data is processed.  This routine
  156.  * is called once per image -- it sets up different
  157.  * state based on whether or not 2D encoding is used.
  158.  */
  159. static void *
  160. Fax3SetupState(TIFF* tif, int space)
  161. {
  162.     TIFFDirectory *td = &tif->tif_dir;
  163.     Fax3BaseState *sp;
  164.     size_t cc = space;
  165.     long rowbytes, rowpixels;
  166.  
  167.     if (td->td_bitspersample != 1) {
  168.         TIFFError(tif->tif_name,
  169.             "Bits/sample must be 1 for Group 3/4 encoding/decoding");
  170.         return (0);
  171.     }
  172.     /*
  173.      * Calculate the scanline/tile widths.
  174.      */
  175.     if (isTiled(tif)) {
  176.         rowbytes = TIFFTileRowSize(tif);
  177.         rowpixels = tif->tif_dir.td_tilewidth;
  178.     } else {
  179.         rowbytes = TIFFScanlineSize(tif);
  180.         rowpixels = tif->tif_dir.td_imagewidth;
  181.     }
  182.     if (is2DEncoding(tif) || td->td_compression == COMPRESSION_CCITTFAX4)
  183.         cc += rowbytes+1;
  184.     tif->tif_data = _TIFFmalloc(cc);
  185.     if (tif->tif_data == NULL) {
  186.         TIFFError("Fax3SetupState",
  187.             "%s: No space for Fax3 state block", tif->tif_name);
  188.         return (0);
  189.     }
  190.     sp = (Fax3BaseState *)tif->tif_data;
  191.     sp->rowbytes = (uint32) rowbytes;
  192.     sp->rowpixels = (uint32) rowpixels;
  193.     sp->bitmap = TIFFGetBitRevTable(tif->tif_fillorder != td->td_fillorder);
  194.     if (is2DEncoding(tif) || td->td_compression == COMPRESSION_CCITTFAX4) {
  195.         /*
  196.          * 2d encoding/decoding requires a scanline
  197.          * buffer for the ``reference line''; the
  198.          * scanline against which delta encoding
  199.          * is referenced.  The reference line must
  200.          * be initialized to be ``white'' (done elsewhere).
  201.          */
  202.         sp->refline = (u_char *)tif->tif_data + space + 1;
  203.         /*
  204.          * Initialize pixel just to the left of the
  205.          * reference line to white.  This extra pixel
  206.          * simplifies the edge-condition logic.
  207.          */
  208.         sp->refline[-1] = 0x00;
  209.     } else
  210.         sp->refline = 0;
  211.     return (sp);
  212. }
  213.  
  214. /*
  215.  * Setup state for decoding a strip.
  216.  */
  217. static
  218. Fax3PreDecode(TIFF* tif)
  219. {
  220.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  221.  
  222.     if (sp == NULL) {
  223.         sp = (Fax3DecodeState *)Fax3SetupState(tif, sizeof (*sp));
  224.         if (!sp)
  225.             return (0);
  226.     }
  227.     sp->b.bit = 0;            /* force initial read */
  228.     sp->b.data = 0;
  229.     sp->b.tag = G3_1D;
  230.     if (sp->b.refline)
  231.         _TIFFmemset(sp->b.refline, 0x00, sp->b.rowbytes);
  232.     /*
  233.      * If image has EOL codes, they precede each line
  234.      * of data.  We skip over the first one here so that
  235.      * when we decode rows, we can use an EOL to signal
  236.      * that less than the expected number of pixels are
  237.      * present for the scanline.
  238.      */
  239.     if ((tif->tif_options & FAX3_NOEOL) == 0) {
  240.         skiptoeol(tif, 0);
  241.         if (is2DEncoding(tif))
  242.             /* tag should always be 1D! */
  243.             sp->b.tag = nextbit(tif) ? G3_1D : G3_2D;
  244.     }
  245.     return (1);
  246. }
  247.  
  248. #define    isAligned(p,t)    ((((u_long)(p)) & (sizeof (t)-1)) == 0)
  249. /*
  250.  * The FILL macro must handle spans < 2*sizeof(long) bytes.
  251.  * For machines with 64-bit longs this is <16 bytes; otherwise
  252.  * this is <8 bytes.  We optimize the code here to reflect the
  253.  * machine characteristics.
  254.  */
  255. #if defined(__alpha) || _MIPS_SZLONG == 64
  256. #define FILL(n, cp)                                \
  257.     switch (n) {                                \
  258.     case 15:(cp)[14] = 0xff; case 14:(cp)[13] = 0xff; case 13: (cp)[12] = 0xff;\
  259.     case 12:(cp)[11] = 0xff; case 11:(cp)[10] = 0xff; case 10: (cp)[9] = 0xff;\
  260.     case  9: (cp)[8] = 0xff; case  8: (cp)[7] = 0xff; case  7: (cp)[6] = 0xff;\
  261.     case  6: (cp)[5] = 0xff; case  5: (cp)[4] = 0xff; case  4: (cp)[3] = 0xff;\
  262.     case  3: (cp)[2] = 0xff; case  2: (cp)[1] = 0xff;                  \
  263.     case  1: (cp)[0] = 0xff; (cp) += (n); case 0:  ;                  \
  264.     }
  265. #else
  266. #define FILL(n, cp)                                \
  267.     switch (n) {                                \
  268.     case 7: (cp)[6] = 0xff; case 6: (cp)[5] = 0xff; case 5: (cp)[4] = 0xff; \
  269.     case 4: (cp)[3] = 0xff; case 3: (cp)[2] = 0xff; case 2: (cp)[1] = 0xff; \
  270.     case 1: (cp)[0] = 0xff; (cp) += (n); case 0:  ;                \
  271.     }
  272. #endif
  273. static const unsigned char _fillmasks[] =
  274.     { 0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
  275.  
  276. /*
  277.  * Fill a span with ones.  Single byte fills are done
  278.  * inline; otherwise _fillspan is called to do the
  279.  * general fill work.
  280.  */
  281. #define    fillspan(cp, x, count) {            \
  282.     if ((count) > 0) {                    \
  283.     char* _cp = (cp) + ((x)>>3);            \
  284.     int32 _x = (x) & 7;                \
  285.     if ((count) <= 8-_x)                \
  286.         _cp[0] |= _fillmasks[(count)]>>_x;        \
  287.     else                        \
  288.         _fillspan(_cp, x, count);            \
  289.     }                            \
  290. }
  291.  
  292. /*
  293.  * Handle fills that span a byte boundary.
  294.  */
  295. static void
  296. _fillspan(char* cp, int32 x, int32 count)
  297. {
  298.     int32 n;
  299.  
  300.     if (x &= 7) {            /* align to byte boundary */
  301.         *cp++ |= 0xff >> x;
  302.         count -= 8-x;
  303.     }
  304.     if (n = count >> 3) {        /* multiple bytes to fill */
  305.         if ((n/sizeof (long)) > 1) {
  306.             int32 nw;
  307.             long* lp;
  308.             /*
  309.              * Align to longword boundary and fill longwords.
  310.              */
  311.             for (; n && !isAligned(cp, long); n--)
  312.                 *cp++ = 0xff;
  313.             lp = (long*) cp;
  314.             nw = (int32)(n / sizeof (long));
  315.             n -= nw * sizeof (long);
  316.             do {
  317.                 *lp++ = -1L;
  318.             } while (--nw);
  319.             cp = (char*) lp;
  320.         }
  321.         FILL(n, cp);
  322.         count &= 7;
  323.     }
  324.     *cp |= _fillmasks[count];
  325. }
  326. #undef    FILL
  327.  
  328. /*
  329.  * Decode the requested amount of data.
  330.  */
  331. static
  332. Fax3Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
  333. {
  334.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  335.     int status;
  336.  
  337.     _TIFFmemset(buf, 0, occ);    /* decoding only sets non-zero bits */
  338.     while ((long)occ > 0) {
  339.         if (sp->b.tag == G3_1D)
  340.             status = Fax3Decode1DRow(tif, buf, sp->b.rowpixels);
  341.         else
  342.             status = Fax3Decode2DRow(tif, buf, sp->b.rowpixels);
  343.         /*
  344.          * For premature EOF, stop decoding and return
  345.          * the buffer with the remainder white-filled.
  346.          */
  347.         if (status == G3CODE_EOF)
  348.             return (status);
  349.         if (is2DEncoding(tif)) {
  350.             /*
  351.              * Fetch the tag bit that indicates
  352.              * whether the next row is 1d or 2d
  353.              * encoded.  If 2d-encoded, then setup
  354.              * the reference line from the decoded
  355.              * scanline just completed.
  356.              */
  357.             sp->b.tag = nextbit(tif) ? G3_1D : G3_2D;
  358.             if (sp->b.tag == G3_2D)
  359.                 _TIFFmemcpy(sp->b.refline, buf, sp->b.rowbytes);
  360.         }
  361.         buf += sp->b.rowbytes;
  362.         occ -= sp->b.rowbytes;
  363.         if (occ != 0)
  364.             tif->tif_row++;
  365.     }
  366.     return (1);
  367. }
  368.  
  369. /*
  370.  * Decode a code and return the associated run length.
  371.  */
  372. static int32
  373. decode_run(TIFF* tif, const u_short fsm[][256])
  374. {
  375.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  376.     int state = sp->b.bit;
  377.     int action;
  378.     int32 runlen = 0;
  379.  
  380.     for (;;) {
  381.         if (state == 0) {
  382.     nextbyte:
  383.             if (tif->tif_rawcc <= 0)
  384.                 return (G3CODE_EOF);
  385.             sp->b.data = fetchByte(tif, sp);
  386.         }
  387.         state = fsm[state][sp->b.data];
  388.         action = state >> 8; state &= 0xff;
  389.         if (action == ACT_INCOMP)
  390.             goto nextbyte;
  391.         sp->b.bit = state;
  392.         action -= ACT_RUNT;
  393.         if (action < 0)            /* ACT_INVALID or ACT_EOL */
  394.             return (action);
  395.         if (action < 64)
  396.             return (runlen + action);
  397.         runlen += 64*(action-64);
  398.     }
  399.     /*NOTREACHED*/
  400. }
  401.  
  402. #define    decode_white_run(tif)    decode_run(tif, TIFFFax1DFSM+0)
  403. #define    decode_black_run(tif)    decode_run(tif, TIFFFax1DFSM+8)
  404.  
  405. /*
  406.  * Process one row of 1d Huffman-encoded data.
  407.  */
  408. static int
  409. Fax3Decode1DRow(TIFF* tif, u_char* buf, uint32 npels)
  410. {
  411.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  412.     int32 x = 0;
  413.     int32 runlen;
  414.     static const char module[] = "Fax3Decode1D";
  415.  
  416.     for (;;) {
  417.         runlen = decode_white_run(tif);
  418.         if (runlen < 0)
  419.             goto exception;
  420.         if ((x += runlen) >= npels) {
  421.             x = npels;
  422.             goto done;
  423.         }
  424.         runlen = decode_black_run(tif);
  425.         if (runlen < 0)
  426.             goto exception;
  427.         if (runlen > 0) {
  428.             if (x+runlen >= npels) {
  429.                 fillspan((char*)buf, x, npels-x);
  430.                 x = npels;
  431.                 goto done;
  432.             }
  433.             fillspan((char*)buf, x, runlen);
  434.             x += runlen;
  435.         }
  436.     }
  437. exception:
  438.     switch (runlen) {
  439.     case G3CODE_EOF:
  440.         TIFFWarning(module, "%s: Premature EOF at scanline %d (x %d)",
  441.             tif->tif_name, tif->tif_row, x);
  442.         return (G3CODE_EOF);
  443.     case G3CODE_INVALID:    /* invalid code */
  444.         /*
  445.          * An invalid code was encountered.
  446.          * Flush the remainder of the line
  447.          * and allow the caller to decide whether
  448.          * or not to continue.  Note that this
  449.          * only works if we have a G3 image
  450.          * with EOL markers.
  451.          */
  452.         TIFFError(module, "%s: Bad code word at scanline %d (x %d)",
  453.            tif->tif_name, tif->tif_row, x);
  454.         break;
  455.     case G3CODE_EOL:    /* premature end-of-line code */
  456.         TIFFWarning(module, "%s: Premature EOL at scanline %d (x %d)",
  457.             tif->tif_name, tif->tif_row, x);
  458.         return (1);    /* try to resynchronize... */
  459.     }
  460. done:
  461.     /*
  462.      * Cleanup at the end of the row.  This convoluted
  463.      * logic is merely so that we can reuse the code with
  464.      * two other related compression algorithms (2 & 32771).
  465.      *
  466.      * Note also that our handling of word alignment assumes
  467.      * that the buffer is at least word aligned.  This is
  468.      * the case for most all versions of malloc (typically
  469.      * the buffer is returned longword aligned).
  470.      */
  471.     if ((tif->tif_options & FAX3_NOEOL) == 0)
  472.         skiptoeol(tif, 0);
  473.     if (tif->tif_options & FAX3_BYTEALIGN)
  474.         sp->b.bit = 0;
  475.     if ((tif->tif_options & FAX3_WORDALIGN) && !isWordAligned(tif))
  476.         (void) fetchByte(tif, sp);
  477.     return (x == npels ? 1 : G3CODE_EOL);
  478. }
  479.  
  480. /*
  481.  * Group 3 2d Decoding support.
  482.  */
  483.  
  484. /*
  485.  * Return the next uncompressed mode code word.
  486.  */
  487. static int
  488. decode_uncomp_code(TIFF* tif)
  489. {
  490.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  491.     int code;
  492.  
  493.     do {
  494.         if (sp->b.bit == 0 || sp->b.bit > 7) {
  495.             if (tif->tif_rawcc <= 0)
  496.                 return (UNCOMP_EOF);
  497.             sp->b.data = fetchByte(tif, sp);
  498.         }
  499.         code = TIFFFaxUncompFSM[sp->b.bit][sp->b.data];
  500.         sp->b.bit = code & 0xff; code >>= 8;
  501.     } while (code == ACT_INCOMP);
  502.     return (code);
  503. }
  504.  
  505. /*
  506.  * Return the offset of the next bit in the range
  507.  * [bs..be] that is different from the specified
  508.  * color.  The end, be, is returned if no such bit
  509.  * exists.
  510.  */
  511. #define    finddiff(_cp, _bs, _be, _color)    \
  512.     (_bs + (_color ? find1span(_cp,_bs,_be) : find0span(_cp,_bs,_be)))
  513.  
  514. /*
  515.  * Process one row of 2d encoded data.
  516.  */
  517. int
  518. Fax3Decode2DRow(TIFF* tif, u_char* buf, uint32 npels)
  519. {
  520. #define    PIXEL(buf,ix)    ((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1)
  521.     int state, data;
  522. #define    CACHE_STATE    { state = sp->b.bit; data = sp->b.data; }
  523. #define    UNCACHE_STATE    { sp->b.bit = state; sp->b.data = data; }
  524.     Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  525.     int32 a0 = -1;
  526.     int32 b1, b2;
  527.     int32 run1, run2;    /* for horizontal mode */
  528.     int mode;
  529.     int color = 0;
  530.     static const char module[] = "Fax3Decode2D";
  531.  
  532.     CACHE_STATE;
  533.     do {
  534.         do {
  535.             if (state == 0 || state > 7) {
  536.                 if (tif->tif_rawcc <= 0) {
  537.                     TIFFError(module,
  538.                         "%s: Premature EOF at scanline %d",
  539.                         tif->tif_name, tif->tif_row);
  540.                     UNCACHE_STATE;
  541.                     return (G3CODE_EOF);
  542.                 }
  543.                 data = fetchByte(tif, sp);
  544.             }
  545.             mode = TIFFFax2DFSM[state][data];
  546.             state = mode & 0xff; mode >>= 8;
  547.         } while (mode == MODE_NULL);
  548.         switch (mode) {
  549.         case MODE_PASS:
  550.             b2 = finddiff(sp->b.refline, a0, npels, !color);
  551.             b1 = finddiff(sp->b.refline, b2, npels, color);
  552.             b2 = finddiff(sp->b.refline, b1, npels, !color);
  553.             if (color) {
  554.                 if (a0 < 0)
  555.                     a0 = 0;
  556.                 fillspan((char *)buf, a0, b2 - a0);
  557.             }
  558.             a0 = b2;
  559.             break;
  560.         case MODE_HORIZ:
  561.             UNCACHE_STATE;
  562.             if (color == 0) {
  563.                 run1 = decode_white_run(tif);
  564.                 run2 = decode_black_run(tif);
  565.             } else {
  566.                 run1 = decode_black_run(tif);
  567.                 run2 = decode_white_run(tif);
  568.             }
  569.             CACHE_STATE;
  570.             if (run1 >= 0 && run2 >= 0) {
  571.                 /*
  572.                  * Do the appropriate fill.  Note that we exit
  573.                  * this logic with the same color that we enter
  574.                  * with since we do 2 fills.  This explains the
  575.                  * somewhat obscure logic below.
  576.                  */
  577.                 if (a0 < 0)
  578.                     a0 = 0;
  579.                 if (a0 + run1 > npels)
  580.                     run1 = npels - a0;
  581.                 if (color)
  582.                     fillspan((char *)buf, a0, run1);
  583.                 a0 += run1;
  584.                 if (a0 + run2 > npels)
  585.                     run2 = npels - a0;
  586.                 if (!color)
  587.                     fillspan((char *)buf, a0, run2);
  588.                 a0 += run2;
  589.             }
  590.             break;
  591.         case MODE_VERT_V0:
  592.         case MODE_VERT_VR1:
  593.         case MODE_VERT_VR2:
  594.         case MODE_VERT_VR3:
  595.         case MODE_VERT_VL1:
  596.         case MODE_VERT_VL2:
  597.         case MODE_VERT_VL3:
  598.             b2 = finddiff(sp->b.refline, a0, npels, !color);
  599.             b1 = finddiff(sp->b.refline, b2, npels, color);
  600.             b1 += mode - MODE_VERT_V0;
  601.             if (color) {
  602.                 if (a0 < 0)
  603.                     a0 = 0;
  604.                 fillspan((char *)buf, a0, b1 - a0);
  605.             }
  606.             color = !color;
  607.             a0 = b1;
  608.             break;
  609.             case MODE_UNCOMP:
  610.             /*
  611.              * Uncompressed mode: select from the
  612.              * special set of code words.
  613.              */
  614.             if (a0 < 0)
  615.                 a0 = 0;
  616.             UNCACHE_STATE;
  617.             do {
  618.                 mode = decode_uncomp_code(tif);
  619.                 switch (mode) {
  620.                 case UNCOMP_RUN1:
  621.                 case UNCOMP_RUN2:
  622.                 case UNCOMP_RUN3:
  623.                 case UNCOMP_RUN4:
  624.                 case UNCOMP_RUN5:
  625.                     run1 = mode - UNCOMP_RUN0;
  626.                     fillspan((char *)buf, a0+run1-1, 1);
  627.                     a0 += run1;
  628.                     break;
  629.                 case UNCOMP_RUN6:
  630.                     a0 += 5;
  631.                     break;
  632.                 case UNCOMP_TRUN0:
  633.                 case UNCOMP_TRUN1:
  634.                 case UNCOMP_TRUN2:
  635.                 case UNCOMP_TRUN3:
  636.                 case UNCOMP_TRUN4:
  637.                     run1 = mode - UNCOMP_TRUN0;
  638.                     a0 += run1;
  639.                     color = nextbit(tif);
  640.                     break;
  641.                 case UNCOMP_INVALID:
  642.                     TIFFError(module,
  643.                 "%s: Bad uncompressed code word at scanline %d",
  644.                         tif->tif_name, tif->tif_row);
  645.                     goto bad;
  646.                 case UNCOMP_EOF:
  647.                     TIFFError(module,
  648.                         "%s: Premature EOF at scanline %d",
  649.                         tif->tif_name, tif->tif_row);
  650.                     return (G3CODE_EOF);
  651.                 }
  652.             } while (mode < UNCOMP_EXIT);
  653.             CACHE_STATE;
  654.             break;
  655.             case MODE_ERROR_1:
  656.             if ((tif->tif_options & FAX3_NOEOL) == 0) {
  657.                 TIFFWarning(module,
  658.                     "%s: Premature EOL at scanline %d (x %d)",
  659.                     tif->tif_name, tif->tif_row, a0);
  660.                 UNCACHE_STATE;
  661.                 skiptoeol(tif, 7);    /* seen 7 0's already */
  662.                 return (1);        /* try to synchronize */
  663.             }
  664.             /* fall thru... */
  665.             case MODE_ERROR:
  666.             TIFFError(module,
  667.                 "%s: Bad 2D code word at scanline %d",
  668.                 tif->tif_name, tif->tif_row);
  669.             UNCACHE_STATE;
  670.             goto bad;
  671.             default:
  672.             TIFFError(module,
  673.                 "%s: Panic, bad decoding state at scanline %d",
  674.                 tif->tif_name, tif->tif_row);
  675.             UNCACHE_STATE;
  676.             return (0);
  677.         }
  678.     } while (a0 < npels);
  679.     UNCACHE_STATE;
  680. bad:
  681.     /*
  682.      * Cleanup at the end of row.  We check for
  683.      * EOL separately so that this code can be
  684.      * reused by the Group 4 decoding routine.
  685.      */
  686.     if ((tif->tif_options & FAX3_NOEOL) == 0)
  687.         skiptoeol(tif, 0);
  688.     return (a0 >= npels ? 1 : G3CODE_EOL);
  689. #undef    UNCACHE_STATE
  690. #undef    CACHE_STATE
  691. #undef    PIXEL
  692. }
  693.  
  694. /*
  695.  * CCITT Group 3 FAX Encoding.
  696.  */
  697.  
  698. /*
  699.  * Write a variable-length bit-value to
  700.  * the output stream.  Values are
  701.  * assumed to be at most 16 bits.
  702.  */
  703. void
  704. Fax3PutBits(TIFF* tif, u_int bits, u_int length)
  705. {
  706.     Fax3BaseState *sp = (Fax3BaseState *)tif->tif_data;
  707.     static const int mask[9] =
  708.         { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
  709.  
  710.     while (length > sp->bit) {
  711.         sp->data |= bits >> (length - sp->bit);
  712.         length -= sp->bit;
  713.         Fax3FlushBits(tif, sp);
  714.     }
  715.     sp->data |= (bits & mask[length]) << (sp->bit - length);
  716.     sp->bit -= length;
  717.     if (sp->bit == 0)
  718.         Fax3FlushBits(tif, sp);
  719. }
  720.  
  721. /*
  722.  * Write a code to the output stream.
  723.  */
  724. static void
  725. putcode(TIFF* tif, const tableentry* te)
  726. {
  727.     Fax3PutBits(tif, te->code, te->length);
  728. }
  729.  
  730. /*
  731.  * Write the sequence of codes that describes
  732.  * the specified span of zero's or one's.  The
  733.  * appropriate table that holds the make-up and
  734.  * terminating codes is supplied.
  735.  */
  736. static void
  737. putspan(TIFF* tif, int32 span, const tableentry* tab)
  738. {
  739.     while (span >= 2624) {
  740.         const tableentry *te = &tab[63 + (2560>>6)];
  741.         putcode(tif, te);
  742.         span -= te->runlen;
  743.     }
  744.     if (span >= 64) {
  745.         const tableentry *te = &tab[63 + (span>>6)];
  746.         assert(te->runlen == 64*(span>>6));
  747.         putcode(tif, te);
  748.         span -= te->runlen;
  749.     }
  750.     putcode(tif, &tab[span]);
  751. }
  752.  
  753. /*
  754.  * Write an EOL code to the output stream.  The zero-fill
  755.  * logic for byte-aligning encoded scanlines is handled
  756.  * here.  We also handle writing the tag bit for the next
  757.  * scanline when doing 2d encoding.
  758.  */
  759. void
  760. Fax3PutEOL(TIFF* tif)
  761. {
  762.     Fax3BaseState *sp = (Fax3BaseState *)tif->tif_data;
  763.  
  764.     if (tif->tif_dir.td_group3options & GROUP3OPT_FILLBITS) {
  765.         /*
  766.          * Force bit alignment so EOL will terminate on
  767.          * a byte boundary.  That is, force the bit alignment
  768.          * to 16-12 = 4 before putting out the EOL code.
  769.          */
  770.         int align = 8 - 4;
  771.         if (align != sp->bit) {
  772.             if (align > sp->bit)
  773.                 align = sp->bit + (8 - align);
  774.             else
  775.                 align = sp->bit - align;
  776.             Fax3PutBits(tif, 0, align);
  777.         }
  778.     }
  779.     Fax3PutBits(tif, EOL, 12);
  780.     if (is2DEncoding(tif))
  781.         Fax3PutBits(tif, sp->tag == G3_1D, 1);
  782. }
  783.  
  784. static const u_char zeroruns[256] = {
  785.     8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,    /* 0x00 - 0x0f */
  786.     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,    /* 0x10 - 0x1f */
  787.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,    /* 0x20 - 0x2f */
  788.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,    /* 0x30 - 0x3f */
  789.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0x40 - 0x4f */
  790.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0x50 - 0x5f */
  791.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0x60 - 0x6f */
  792.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0x70 - 0x7f */
  793.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x80 - 0x8f */
  794.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x90 - 0x9f */
  795.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0xa0 - 0xaf */
  796.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0xb0 - 0xbf */
  797.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0xc0 - 0xcf */
  798.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0xd0 - 0xdf */
  799.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0xe0 - 0xef */
  800.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0xf0 - 0xff */
  801. };
  802. static const u_char oneruns[256] = {
  803.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x00 - 0x0f */
  804.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x10 - 0x1f */
  805.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x20 - 0x2f */
  806.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x30 - 0x3f */
  807.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x40 - 0x4f */
  808.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x50 - 0x5f */
  809.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x60 - 0x6f */
  810.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* 0x70 - 0x7f */
  811.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0x80 - 0x8f */
  812.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0x90 - 0x9f */
  813.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0xa0 - 0xaf */
  814.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 0xb0 - 0xbf */
  815.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,    /* 0xc0 - 0xcf */
  816.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,    /* 0xd0 - 0xdf */
  817.     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,    /* 0xe0 - 0xef */
  818.     4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8,    /* 0xf0 - 0xff */
  819. };
  820.  
  821. /*
  822.  * Reset encoding state at the start of a strip.
  823.  */
  824. static
  825. Fax3PreEncode(TIFF* tif)
  826. {
  827.     Fax3EncodeState *sp = (Fax3EncodeState *)tif->tif_data;
  828.  
  829.     if (sp == NULL) {
  830.         sp = (Fax3EncodeState *)Fax3SetupState(tif, sizeof (*sp));
  831.         if (!sp)
  832.             return (0);
  833.     }
  834.     sp->b.bit = 8;
  835.     sp->b.data = 0;
  836.     sp->b.tag = G3_1D;
  837.     /*
  838.      * This is necessary for Group 4; otherwise it isn't
  839.      * needed because the first scanline of each strip ends
  840.      * up being copied into the refline.
  841.      */
  842.     if (sp->b.refline)
  843.         _TIFFmemset(sp->b.refline, 0x00, sp->b.rowbytes);
  844.     if (is2DEncoding(tif)) {
  845.         float res = tif->tif_dir.td_yresolution;
  846.         /*
  847.          * The CCITT spec says that when doing 2d encoding, you
  848.          * should only do it on K consecutive scanlines, where K
  849.          * depends on the resolution of the image being encoded
  850.          * (2 for <= 200 lpi, 4 for > 200 lpi).  Since the directory
  851.          * code initializes td_yresolution to 0, this code will
  852.          * select a K of 2 unless the YResolution tag is set
  853.          * appropriately.  (Note also that we fudge a little here
  854.          * and use 150 lpi to avoid problems with units conversion.)
  855.          */
  856.         if (tif->tif_dir.td_resolutionunit == RESUNIT_CENTIMETER)
  857.             res = (res * .3937f) / 2.54f;    /* convert to inches */
  858.         sp->maxk = (res > 150 ? 4 : 2);
  859.         sp->k = sp->maxk-1;
  860.     } else
  861.         sp->k = sp->maxk = 0;
  862.     return (1);
  863. }
  864.  
  865. /*
  866.  * 1d-encode a row of pixels.  The encoding is
  867.  * a sequence of all-white or all-black spans
  868.  * of pixels encoded with Huffman codes.
  869.  */
  870. static int
  871. Fax3Encode1DRow(TIFF* tif, u_char* bp, uint32 bits)
  872. {
  873.     Fax3EncodeState *sp = (Fax3EncodeState *)tif->tif_data;
  874.     int32 bs = 0, span;
  875.  
  876.     for (;;) {
  877.         span = find0span(bp, bs, bits);        /* white span */
  878.         putspan(tif, span, TIFFFaxWhiteCodes);
  879.         bs += span;
  880.         if (bs >= bits)
  881.             break;
  882.         span = find1span(bp, bs, bits);        /* black span */
  883.         putspan(tif, span, TIFFFaxBlackCodes);
  884.         bs += span;
  885.         if (bs >= bits)
  886.             break;
  887.     }
  888.     if (tif->tif_options & (FAX3_BYTEALIGN|FAX3_WORDALIGN)) {
  889.         Fax3PutBits(tif, 0, sp->b.bit);
  890.         if ((tif->tif_options & FAX3_WORDALIGN) && !isWordAligned(tif))
  891.             Fax3PutBits(tif, 0, 8);
  892.     }
  893.     return (1);
  894. }
  895.  
  896. static const tableentry horizcode =
  897.     { 3, 0x1 };        /* 001 */
  898. static const tableentry passcode =
  899.     { 4, 0x1 };        /* 0001 */
  900. static const tableentry vcodes[7] = {
  901.     { 7, 0x03 },    /* 0000 011 */
  902.     { 6, 0x03 },    /* 0000 11 */
  903.     { 3, 0x03 },    /* 011 */
  904.     { 1, 0x1 },        /* 1 */
  905.     { 3, 0x2 },        /* 010 */
  906.     { 6, 0x02 },    /* 0000 10 */
  907.     { 7, 0x02 }        /* 0000 010 */
  908. };
  909.  
  910. /*
  911.  * 2d-encode a row of pixels.  Consult the CCITT
  912.  * documentation for the algorithm.
  913.  */
  914. int
  915. Fax3Encode2DRow(TIFF* tif, u_char* bp, u_char* rp, uint32 bits)
  916. {
  917. #define    PIXEL(buf,ix)    ((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1)
  918.     int32 a0 = 0;
  919.     int32 a1 = (PIXEL(bp, 0) != 0 ? 0 : finddiff(bp, 0, bits, 0));
  920.     int32 b1 = (PIXEL(rp, 0) != 0 ? 0 : finddiff(rp, 0, bits, 0));
  921.     int32 a2, b2;
  922.  
  923.     for (;;) {
  924.         b2 = finddiff(rp, b1, bits, PIXEL(rp,b1));
  925.         if (b2 >= a1) {
  926.             int d = b1 - a1;
  927.             if (!(-3 <= d && d <= 3)) {    /* horizontal mode */
  928.                 a2 = finddiff(bp, a1, bits, PIXEL(bp,a1));
  929.                 putcode(tif, &horizcode);
  930.                 if (a0+a1 == 0 || PIXEL(bp, a0) == 0) {
  931.                     putspan(tif, a1-a0, TIFFFaxWhiteCodes);
  932.                     putspan(tif, a2-a1, TIFFFaxBlackCodes);
  933.                 } else {
  934.                     putspan(tif, a1-a0, TIFFFaxBlackCodes);
  935.                     putspan(tif, a2-a1, TIFFFaxWhiteCodes);
  936.                 }
  937.                 a0 = a2;
  938.             } else {            /* vertical mode */
  939.                 putcode(tif, &vcodes[d+3]);
  940.                 a0 = a1;
  941.             }
  942.         } else {                /* pass mode */
  943.             putcode(tif, &passcode);
  944.             a0 = b2;
  945.         }
  946.         if (a0 >= bits)
  947.             break;
  948.         a1 = finddiff(bp, a0, bits, PIXEL(bp,a0));
  949.         b1 = finddiff(rp, a0, bits, !PIXEL(bp,a0));
  950.         b1 = finddiff(rp, b1, bits, PIXEL(bp,a0));
  951.     }
  952.     return (1);
  953. #undef PIXEL
  954. }
  955.  
  956. /*
  957.  * Encode a buffer of pixels.
  958.  */
  959. static int
  960. Fax3Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
  961. {
  962.     Fax3EncodeState *sp = (Fax3EncodeState *)tif->tif_data;
  963.  
  964.     while ((long)cc > 0) {
  965.         if ((tif->tif_options & FAX3_NOEOL) == 0)
  966.             Fax3PutEOL(tif);
  967.         if (is2DEncoding(tif)) {
  968.             if (sp->b.tag == G3_1D) {
  969.                 if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
  970.                     return (0);
  971.                 sp->b.tag = G3_2D;
  972.             } else {
  973.                 if (!Fax3Encode2DRow(tif, bp, sp->b.refline, sp->b.rowpixels))
  974.                     return (0);
  975.                 sp->k--;
  976.             }
  977.             if (sp->k == 0) {
  978.                 sp->b.tag = G3_1D;
  979.                 sp->k = sp->maxk-1;
  980.             } else
  981.                 _TIFFmemcpy(sp->b.refline, bp, sp->b.rowbytes);
  982.         } else {
  983.             if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels))
  984.                 return (0);
  985.         }
  986.         bp += sp->b.rowbytes;
  987.         cc -= sp->b.rowbytes;
  988.         if (cc != 0)
  989.             tif->tif_row++;
  990.     }
  991.     return (1);
  992. }
  993.  
  994. static int
  995. Fax3PostEncode(TIFF* tif)
  996. {
  997.     Fax3BaseState *sp = (Fax3BaseState *)tif->tif_data;
  998.  
  999.     if (sp->bit != 8)
  1000.         Fax3FlushBits(tif, sp);
  1001.     return (1);
  1002. }
  1003.  
  1004. static void
  1005. Fax3Close(TIFF* tif)
  1006. {
  1007.     if ((tif->tif_options & FAX3_CLASSF) == 0) {    /* append RTC */
  1008.         int i;
  1009.         for (i = 0; i < 6; i++) {
  1010.             Fax3PutBits(tif, EOL, 12);
  1011.             if (is2DEncoding(tif))
  1012.                 Fax3PutBits(tif, 1, 1);
  1013.         }
  1014.         (void) Fax3PostEncode(tif);
  1015.     }
  1016. }
  1017.  
  1018. static void
  1019. Fax3Cleanup(TIFF* tif)
  1020. {
  1021.     if (tif->tif_data) {
  1022.         _TIFFfree(tif->tif_data);
  1023.         tif->tif_data = NULL;
  1024.     }
  1025. }
  1026.  
  1027. /*
  1028.  * Find a span of ones or zeros using the supplied
  1029.  * table.  The ``base'' of the bit string is supplied
  1030.  * along with the start+end bit indices.
  1031.  */
  1032.  
  1033. static int32
  1034. find0span(u_char* bp, int32 bs, int32 be)
  1035. {
  1036.     int32 bits = be - bs;
  1037.     int32 n, span;
  1038.  
  1039.     bp += bs>>3;
  1040.     /*
  1041.      * Check partial byte on lhs.
  1042.      */
  1043.     if (bits > 0 && (n = (bs & 7))) {
  1044.         span = zeroruns[(*bp << n) & 0xff];
  1045.         if (span > 8-n)        /* table value too generous */
  1046.             span = 8-n;
  1047.         if (span > bits)    /* constrain span to bit range */
  1048.             span = bits;
  1049.         if (n+span < 8)        /* doesn't extend to edge of byte */
  1050.             return (span);
  1051.         bits -= span;
  1052.         bp++;
  1053.     } else
  1054.         span = 0;
  1055.     if (bits >= 2*8*sizeof (long)) {
  1056.         long* lp;
  1057.         /*
  1058.          * Align to longword boundary and check longwords.
  1059.          */
  1060.         while (!isAligned(bp, long)) {
  1061.             if (*bp != 0x00)
  1062.                 return (span + zeroruns[*bp]);
  1063.             span += 8, bits -= 8;
  1064.             bp++;
  1065.         }
  1066.         lp = (long*) bp;
  1067.         while (bits >= 8*sizeof (long) && *lp == 0) {
  1068.             span += 8*sizeof (long), bits -= 8*sizeof (long);
  1069.             lp++;
  1070.         }
  1071.         bp = (u_char*) lp;
  1072.     }
  1073.     /*
  1074.      * Scan full bytes for all 0's.
  1075.      */
  1076.     while (bits >= 8) {
  1077.         if (*bp != 0x00)    /* end of run */
  1078.             return (span + zeroruns[*bp]);
  1079.         span += 8, bits -= 8;
  1080.         bp++;
  1081.     }
  1082.     /*
  1083.      * Check partial byte on rhs.
  1084.      */
  1085.     if (bits > 0) {
  1086.         n = zeroruns[*bp];
  1087.         span += (n > bits ? bits : n);
  1088.     }
  1089.     return (span);
  1090. }
  1091.  
  1092. static int32
  1093. find1span(u_char* bp, int32 bs, int32 be)
  1094. {
  1095.     int32 bits = be - bs;
  1096.     int32 n, span;
  1097.  
  1098.     bp += bs>>3;
  1099.     /*
  1100.      * Check partial byte on lhs.
  1101.      */
  1102.     if (bits > 0 && (n = (bs & 7))) {
  1103.         span = oneruns[(*bp << n) & 0xff];
  1104.         if (span > 8-n)        /* table value too generous */
  1105.             span = 8-n;
  1106.         if (span > bits)    /* constrain span to bit range */
  1107.             span = bits;
  1108.         if (n+span < 8)        /* doesn't extend to edge of byte */
  1109.             return (span);
  1110.         bits -= span;
  1111.         bp++;
  1112.     } else
  1113.         span = 0;
  1114.     if (bits >= 2*8*sizeof (long)) {
  1115.         long* lp;
  1116.         /*
  1117.          * Align to longword boundary and check longwords.
  1118.          */
  1119.         while (!isAligned(bp, long)) {
  1120.             if (*bp != 0xff)
  1121.                 return (span + oneruns[*bp]);
  1122.             span += 8, bits -= 8;
  1123.             bp++;
  1124.         }
  1125.         lp = (long*) bp;
  1126.         while (bits >= 8*sizeof (long) && *lp == ~0) {
  1127.             span += 8*sizeof (long), bits -= 8*sizeof (long);
  1128.             lp++;
  1129.         }
  1130.         bp = (u_char*) lp;
  1131.     }
  1132.     /*
  1133.      * Scan full bytes for all 1's.
  1134.      */
  1135.     while (bits >= 8) {
  1136.         if (*bp != 0xff)    /* end of run */
  1137.             return (span + oneruns[*bp]);
  1138.         span += 8, bits -= 8;
  1139.         bp++;
  1140.     }
  1141.     /*
  1142.      * Check partial byte on rhs.
  1143.      */
  1144.     if (bits > 0) {
  1145.         n = oneruns[*bp];
  1146.         span += (n > bits ? bits : n);
  1147.     }
  1148.     return (span);
  1149. }
  1150.  
  1151. int
  1152. TIFFInitCCITTFax3(TIFF* tif)
  1153. {
  1154.     tif->tif_predecode = Fax3PreDecode;
  1155.     tif->tif_decoderow = Fax3Decode;
  1156.     tif->tif_decodestrip = Fax3Decode;
  1157.     tif->tif_decodetile = Fax3Decode;
  1158.     tif->tif_preencode = Fax3PreEncode;
  1159.     tif->tif_postencode = Fax3PostEncode;
  1160.     tif->tif_encoderow = Fax3Encode;
  1161.     tif->tif_encodestrip = Fax3Encode;
  1162.     tif->tif_encodetile = Fax3Encode;
  1163.     tif->tif_close = Fax3Close;
  1164.     tif->tif_cleanup = Fax3Cleanup;
  1165.     tif->tif_options |= FAX3_CLASSF;    /* default */
  1166.     tif->tif_flags |= TIFF_NOBITREV;    /* we handle bit reversal */
  1167.     return (1);
  1168. }
  1169.